package tui

import (
	"fmt"
	"path/filepath"
	"strings"
	"time"

	"anders-cli/internal/ai"
	"anders-cli/internal/config"
	"anders-cli/pkg/logger"

	tea "github.com/charmbracelet/bubbletea"
)

// 消息类型已在 model.go 中定义

// handleKeyMsg 处理键盘消息
func (m *Model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	// 调试：记录键盘事件（生产环境可移除）
	// logger.Info(fmt.Sprintf("键盘事件: 类型=%v, 字符='%s', 原始字符='%s'",
	//	msg.Type, msg.String(), string(msg.Runes)))

	switch msg.Type {
	case tea.KeyCtrlC:
		m.addToHistory("system", "再见！感谢使用 Grok CLI。")
		return m, tea.Quit

		// Enter 键的处理已经在上面处理过了

	case tea.KeyBackspace, tea.KeyDelete:
		if m.focus == focusInput && len(m.input) > 0 && m.cursor > 0 {
			// 删除光标前的一个字符（支持UTF-8）
			runes := []rune(m.input)
			if m.cursor <= len(runes) {
				// 删除光标前的一个字符
				runes = append(runes[:m.cursor-1], runes[m.cursor:]...)
				m.input = string(runes)
				m.cursor--
			}
		}

	case tea.KeySpace:
		if m.focus == focusInput {
			m.input = m.insertAtCursor(m.input, m.cursor, " ")
			m.cursor++
		}

	case tea.KeyRunes:
		if m.focus == focusInput {
			// 插入字符到光标位置
			runesStr := string(msg.Runes)
			m.input = m.insertAtCursor(m.input, m.cursor, runesStr)
			// 对于中文字符，使用rune计数而不是字节计数
			m.cursor += len([]rune(runesStr))
		}

	case tea.KeyLeft:
		if m.focus == focusInput && m.cursor > 0 {
			// 左移光标（支持UTF-8）
			m.cursor--
		}

	case tea.KeyRight:
		if m.focus == focusInput {
			runes := []rune(m.input)
			if m.cursor < len(runes) {
				// 右移光标（支持UTF-8）
				m.cursor++
			}
		}

	case tea.KeyHome:
		if m.focus == focusInput {
			m.cursor = 0
		}

	case tea.KeyEnd:
		if m.focus == focusInput {
			m.cursor = len(m.input)
		}

	case tea.KeyTab:
		if m.focus == focusInput {
			return m.handleTabCompletion()
		}

	case tea.KeyUp:
		if m.showModelSelector {
			// 模型选择器向上移动
			if m.modelCursor > 0 {
				m.modelCursor--
			}
		} else if m.focus == focusInput {
			return m.handleHistoryNavigation(-1)
		}

	case tea.KeyDown:
		if m.showModelSelector {
			// 模型选择器向下移动
			if m.modelCursor < len(m.availableModels)-1 {
				m.modelCursor++
			}
		} else if m.focus == focusInput {
			return m.handleHistoryNavigation(1)
		}

	case tea.KeyEnter:
		if m.showModelSelector {
			// 确认模型选择
			m.handleModelSelection()
		} else if m.focus == focusInput && m.input != "" && !m.loading {
			// 在正常输入状态下发送消息
			return m.handleEnter()
		}

	case tea.KeyF12:
		// F12键：暂停/继续多Agent协作
		return m.handlePauseResume()

	case tea.KeyEsc:
		if m.showModelSelector {
			// 取消模型选择
			m.showModelSelector = false
		} else {
			m.addToHistory("system", "再见！感谢使用 Grok CLI。")
			return m, tea.Quit
		}

	case tea.KeyCtrlL:
		// 清屏
		m.history = []HistoryEntry{
			{
				Timestamp: time.Now(),
				Role:      "system",
				Content:   "屏幕已清空。",
			},
		}
		m.historyOffset = 0

	case tea.KeyPgUp:
		// 向上滚动一页
		if m.historyOffset > 0 {
			scrollAmount := m.historyHeight - 2 // 留出一些重叠
			if scrollAmount < 1 {
				scrollAmount = 1
			}
			m.historyOffset -= scrollAmount
			if m.historyOffset < 0 {
				m.historyOffset = 0
			}
		}

	case tea.KeyPgDown:
		// 向下滚动一页
		scrollAmount := m.historyHeight - 2 // 留出一些重叠
		if scrollAmount < 1 {
			scrollAmount = 1
		}
		m.historyOffset += scrollAmount

	case tea.KeyCtrlE:
		// 清除错误状态
		if m.showError {
			m.clearError()
			m.addToHistory("system", "✅ 错误已清除")
		}
	}

	return m, nil
}

// handleEnter 处理回车键
func (m *Model) handleEnter() (tea.Model, tea.Cmd) {
	userInput := strings.TrimSpace(m.input)

	// 处理用户输入

	// 清空输入
	m.input = ""
	m.cursor = 0

	// 处理特殊命令
	if strings.HasPrefix(userInput, "/") {
		return m.handleCommand(userInput), nil
	}

	// 检查是否在暂停模式
	if m.isPaused && m.pausePromptMode {
		// 在暂停模式下，用户输入是给PM的指令
		model, cmd := m.handlePauseModeInput(userInput)
		return model, cmd
	}

	// 添加用户消息到历史
	m.addToHistory("user", userInput)

	// 保存任务信息（用于报告生成）
	m.lastTask = userInput
	m.lastResponse = ""
	m.lastConfidence = 0
	m.lastFeedback = ""

	// 检查是否包含文件引用
	processedInput := m.processFileReferences(userInput)

	// 检查请求频率限制
	if m.requestLimiter != nil && !m.requestLimiter.Allow() {
		waitTime := m.requestLimiter.GetWaitTime()
		return m, tea.Cmd(func() tea.Msg {
			return errorMsg{err: fmt.Errorf("请求过于频繁，请等待 %.1f 秒", waitTime.Seconds())}
		})
	}

	// 设置加载状态
	m.loading = true

	// 发送AI查询
	return m, tea.Cmd(func() tea.Msg {
		defer func() {
			m.loading = false
			// 清理推理过程状态
			m.showReasoning = false
			m.currentReasoning = ""
		}()

		if m.multiAgentMgr == nil {
			logger.Error("多Agent管理器未初始化")
			return errorMsg{err: &AIError{message: "系统初始化异常，请稍后重试"}}
		}

		// 设置推理过程回调
		reasoningCallback := func(reasoning string) {
			m.currentReasoning = reasoning
			m.showReasoning = true
			logger.Info("AI推理过程更新: %s", reasoning[:min(100, len(reasoning))])
		}

		// 使用多Agent管理器处理查询，增加推理过程显示
		response, confidence, feedback := m.multiAgentMgr.ProcessQueryWithReasoning(processedInput, nil, reasoningCallback)

		// 检查是否为超时或其他错误情况
		if response == "" {
			logger.Error("AI查询无响应，可能超时")
			return errorMsg{err: &AIError{message: "当前模型超时无返回，请稍后重试"}}
		}

		// 保存响应信息
		m.lastResponse = response
		m.lastConfidence = confidence
		m.lastFeedback = feedback

		// 在响应中包含置信度和反馈信息
		enhancedResponse := response
		if confidence > 0 {
			enhancedResponse += fmt.Sprintf("\n\n[置信度: %d%%]", confidence)
		}
		if feedback != "" {
			enhancedResponse += fmt.Sprintf("\n[反馈: %s]", feedback)
		}

		// 如果有推理过程，在响应中也包含推理信息
		if m.currentReasoning != "" {
			enhancedResponse += fmt.Sprintf("\n\n[推理过程: %s]", m.currentReasoning)
		}

		// 如果响应过长，添加摘要信息
		if len(enhancedResponse) > 1000 {
			summary := m.generateResponseSummary(enhancedResponse, confidence, feedback)
			enhancedResponse = summary + "\n\n" + "[完整响应过长，按 ↓ 键向下滚动查看，或使用更大窗口获得更好体验]" + "\n\n" + enhancedResponse
		}

		// 确定Agent名称
		agentName := m.determineAgentName()

		return aiResponseMsg{content: enhancedResponse, agentName: agentName}
	})
}

// handleCommand 处理命令
func (m *Model) handleCommand(cmd string) *Model {
	// 解析命令和参数
	parts := strings.Fields(cmd)
	command := parts[0]
	var args []string
	if len(parts) > 1 {
		args = parts[1:]
	}

	logger.Info("处理命令: %s, 参数: %v", command, args)

	switch command {
	case "/quit", "/exit":
		m.addToHistory("system", "再见！感谢使用 Grok CLI。")
		// 这里可以设置退出标志

	case "/expert":
		if m.multiAgentMgr != nil {
			err := m.multiAgentMgr.SetMode("expert")
			if err != nil {
				m.addToHistory("system", "❌ 切换到专家模式失败: "+err.Error())
			} else {
				m.addToHistory("system", "✅ 已切换到专家模式（单一AI响应）")
			}
		} else {
			m.addToHistory("system", "❌ 多Agent管理器未初始化")
		}

	case "/team":
		if m.multiAgentMgr != nil {
			// 检查是否有项目名称参数
			if len(args) > 0 {
				projectName := args[0]
				logger.Info("尝试切换到团队模式项目: %s", projectName)

				// 这里将在后续步骤中实现项目管理和状态恢复
				err := m.multiAgentMgr.SetMode("team")
				if err != nil {
					m.addToHistory("system", "❌ 切换到团队模式失败: "+err.Error())
				} else {
					m.addToHistory("system", fmt.Sprintf("✅ 已切换到团队模式项目: '%s'", projectName))
					m.addToHistory("system", "📝 项目状态恢复功能将在后续版本中实现")
				}
			} else {
				// 无参数模式，进入通用团队模式
				err := m.multiAgentMgr.SetMode("team")
				if err != nil {
					m.addToHistory("system", "❌ 切换到团队模式失败: "+err.Error())
				} else {
					m.addToHistory("system", "✅ 已切换到团队模式（多Agent协作）")
					m.addToHistory("system", "💡 提示: 使用 '/team 项目名称' 来创建或恢复特定项目")
				}
			}
		} else {
			m.addToHistory("system", "❌ 多Agent管理器未初始化")
		}

	case "/help":
		helpText := `可用命令:
/help - 显示此帮助信息
/quit 或 /exit - 退出程序
/clear - 清空历史记录
/status - 显示系统状态

文件引用语法:
@文件路径 - 引用文件内容

快捷键:
Ctrl+C - 退出程序
左右箭头 - 移动光标
回车 - 发送消息`
		m.addToHistory("system", helpText)

	case "/clear":
		m.history = []HistoryEntry{
			{
				Timestamp: time.Now(),
				Role:      "system",
				Content:   "历史记录已清空。",
			},
		}

	case "/status":
		status := "系统状态:\n"
		if m.aiBackend != nil {
			status += "✅ AI后端: " + m.aiBackend.Name() + "\n"
		} else {
			status += "❌ AI后端: 未初始化\n"
		}

		// 多Agent状态
		if m.multiAgentMgr != nil {
			status += m.multiAgentMgr.GetModeStatus() + "\n"
		} else {
			status += "❌ 多Agent管理器: 未初始化\n"
		}

		status += "✅ 工具调用器: 已初始化\n"
		status += "✅ 历史记录: " + fmt.Sprintf("%d", len(m.history)) + " 条消息\n"

		// 添加性能信息
		if m.performanceMonitor != nil {
			stats := m.performanceMonitor.GetStats()
			status += fmt.Sprintf("🧠 内存使用: %s\n", stats.FormatMemoryUsage())
			status += fmt.Sprintf("⚡ Goroutines: %d\n", stats.Goroutines)
			status += fmt.Sprintf("⏱️ 运行时间: %v\n", stats.Uptime.Round(time.Second))
		}

		if m.connectionPool != nil {
			status += fmt.Sprintf("🔗 连接池: %d 个连接\n", m.connectionPool.Size())
		}

		m.addToHistory("system", status)

	case "/report":
		if m.multiAgentMgr != nil && m.lastTask != "" && m.lastResponse != "" {
			err := m.multiAgentMgr.GenerateReport(m.lastTask, m.lastResponse, m.lastConfidence, m.lastFeedback)
			if err != nil {
				m.addToHistory("system", "❌ 生成报告失败: "+err.Error())
			} else {
				m.addToHistory("system", "✅ 多Agent协作报告已生成")
			}
		} else if m.lastTask == "" {
			m.addToHistory("system", "❌ 没有可用的任务信息，请先执行一个任务")
		} else {
			m.addToHistory("system", "❌ 多Agent管理器未初始化或没有响应数据")
		}

	case "/list-projects":
		// 列出所有项目
		// TODO: 这里将在后续实现中集成数据库查询
		m.addToHistory("system", "📋 项目列表功能将在后续版本中实现")
		m.addToHistory("system", "💡 目前支持的项目类型:")
		m.addToHistory("system", "  • 团队模式项目: 使用 '/team 项目名称' 创建")
		m.addToHistory("system", "  • 专家模式: 默认的单一AI模式")

	case "/models":
		m.showModelSelection()
		return m

	default:
		m.addToHistory("system", "未知命令: "+cmd+"\n输入 /help 查看可用命令")
	}

	return m
}

// handleAIResponse 处理AI响应
func (m *Model) handleAIResponse(msg aiResponseMsg) (tea.Model, tea.Cmd) {
	m.loading = false

	// 保存最后一次响应信息（用于报告生成）
	if m.multiAgentMgr != nil && m.lastTask != "" {
		m.lastResponse = msg.content
	}

	m.addToHistoryWithAgent("assistant", msg.content, msg.agentName)
	return m, nil
}

// determineAgentName 确定当前Agent名称
func (m *Model) determineAgentName() string {
	if m.multiAgentMgr == nil {
		return "Victor (专家)"
	}

	mode := m.multiAgentMgr.GetCurrentMode()
	if mode == "expert" {
		return "Victor (专家)"
	} else if mode == "team" {
		// 团队模式下，根据当前项目或默认显示PM名称
		if m.currentProject != "" {
			return "Anders (项目经理)"
		}
		return "Anders (项目经理)"
	}

	return "AI"
}

// 这些方法已在 model.go 中定义

// processFileReferences 处理文件引用
func (m *Model) processFileReferences(input string) string {
	// 检查是否包含 @ 文件引用
	if !strings.Contains(input, "@") {
		return input
	}

	// 使用正则表达式查找所有文件引用
	// 支持 @file.txt, @./path/file.go, @*.go 等格式
	parts := strings.Split(input, "@")
	if len(parts) < 2 {
		return input
	}

	processedInput := parts[0] // 保留原有的文本部分
	fileContents := make([]string, 0)

	// 处理每个文件引用
	for i := 1; i < len(parts); i++ {
		part := strings.TrimSpace(parts[i])

		// 查找文件引用结束的位置（遇到空格或换行符）
		filePath := part
		remainingText := ""

		// 查找第一个空格或换行符
		if spaceIdx := strings.IndexAny(part, " \n\t"); spaceIdx != -1 {
			filePath = part[:spaceIdx]
			remainingText = part[spaceIdx:]
		}

		// 如果是第一个文件引用后的文本，保留到下一个 @
		if i == 1 {
			remainingText = part[len(filePath):]
		}

		logger.Info("检测到文件引用: %s", filePath)

		// 读取文件内容
		fileContent, err := m.readFileContent(filePath)
		if err != nil {
			logger.Error("读取文件失败 %s: %v", filePath, err)
			fileContent = fmt.Sprintf("[文件读取失败: %s - %v]", filePath, err)
		}

		fileContents = append(fileContents, fmt.Sprintf("=== 文件: %s ===\n%s", filePath, fileContent))

		// 添加剩余的文本（如果有的话）
		if remainingText != "" && i < len(parts)-1 {
			processedInput += remainingText
		}
	}

	// 如果有文件内容，添加到提示词中
	if len(fileContents) > 0 {
		filesText := strings.Join(fileContents, "\n\n")
		processedInput += "\n\n请直接分析以下已提供的文件内容（无需调用工具读取文件）：\n\n" + filesText
		logger.Info("已注入 %d 个文件的内容", len(fileContents))
	}

	return processedInput
}

// readFileContent 读取文件内容，支持通配符
func (m *Model) readFileContent(filePath string) (string, error) {
	// 检查是否包含通配符
	if strings.Contains(filePath, "*") {
		return m.readFilesWithPattern(filePath)
	}

	// 单个文件读取
	return m.toolCaller.ExecuteTool(map[string]interface{}{
		"function": map[string]interface{}{
			"name":      "read_file",
			"arguments": fmt.Sprintf(`{"file_path":"%s"}`, filePath),
		},
	})
}

// readFilesWithPattern 读取匹配模式的文件
func (m *Model) readFilesWithPattern(pattern string) (string, error) {
	// 这里可以扩展为使用 filepath.Glob 来匹配多个文件
	// 目前先返回单个文件的处理结果
	return m.toolCaller.ExecuteTool(map[string]interface{}{
		"function": map[string]interface{}{
			"name":      "read_file",
			"arguments": fmt.Sprintf(`{"file_path":"%s"}`, pattern),
		},
	})
}

// insertAtCursor 在指定位置插入字符串（支持UTF-8）
func (m *Model) insertAtCursor(text string, pos int, insert string) string {
	runes := []rune(text)
	if pos < 0 {
		pos = 0
	}
	if pos > len(runes) {
		pos = len(runes)
	}

	// 在指定位置插入字符
	result := make([]rune, len(runes)+len([]rune(insert)))
	copy(result, runes[:pos])
	copy(result[pos:], []rune(insert))
	copy(result[pos+len([]rune(insert)):], runes[pos:])

	return string(result)
}

// handleTabCompletion 处理Tab补全
func (m *Model) handleTabCompletion() (tea.Model, tea.Cmd) {
	// 简单的文件路径补全
	input := m.input[:m.cursor]
	words := strings.Fields(input)

	if len(words) == 0 {
		return m, nil
	}

	lastWord := words[len(words)-1]

	// 检查是否是文件路径
	if strings.Contains(lastWord, "/") || strings.Contains(lastWord, "\\") {
		// 尝试补全文件路径
		if completed := m.completeFilePath(lastWord); completed != "" {
			// 替换最后一个词
			newInput := strings.TrimSuffix(input, lastWord) + completed
			m.input = newInput + m.input[m.cursor:]
			m.cursor = len(newInput)
		}
	}

	return m, nil
}

// completeFilePath 补全文件路径
func (m *Model) completeFilePath(prefix string) string {
	// 简单的文件路径补全逻辑
	// 这里可以扩展为更复杂的补全逻辑

	// 如果以@开头，说明是文件引用
	if strings.HasPrefix(prefix, "@") {
		prefix = prefix[1:]
	}

	// 查找匹配的文件
	matches, err := filepath.Glob(prefix + "*")
	if err != nil || len(matches) == 0 {
		return ""
	}

	// 如果只有一个匹配，补全它
	if len(matches) == 1 {
		match := matches[0]
		if strings.HasPrefix(prefix, "@") {
			return "@" + match
		}
		return match
	}

	// 多个匹配，返回最长的公共前缀
	commonPrefix := matches[0]
	for _, match := range matches[1:] {
		commonPrefix = findCommonPrefix(commonPrefix, match)
	}

	if commonPrefix != prefix {
		if strings.HasPrefix(prefix, "@") {
			return "@" + commonPrefix
		}
		return commonPrefix
	}

	return ""
}

// findCommonPrefix 查找两个字符串的公共前缀
func findCommonPrefix(a, b string) string {
	minLen := len(a)
	if len(b) < minLen {
		minLen = len(b)
	}

	for i := 0; i < minLen; i++ {
		if a[i] != b[i] {
			return a[:i]
		}
	}

	return a[:minLen]
}

// handleHistoryNavigation 处理历史记录导航
func (m *Model) handleHistoryNavigation(direction int) (tea.Model, tea.Cmd) {
	// 简单的历史导航实现
	// 这里可以扩展为更复杂的导航逻辑
	return m, nil
}

// showModelSelection 显示模型选择器
func (m *Model) showModelSelection() {
	m.showModelSelector = true
	m.modelCursor = 0 // 重置光标到第一个模型

	// 找到当前使用的模型
	if m.aiBackend != nil {
		currentName := m.aiBackend.Name()
		for i, model := range m.availableModels {
			if strings.Contains(model, currentName) {
				m.modelCursor = i
				break
			}
		}
	}
}

// handleModelSelection 处理模型选择
func (m *Model) handleModelSelection() {
	if m.modelCursor >= 0 && m.modelCursor < len(m.availableModels) {
		selectedModel := m.availableModels[m.modelCursor]

		// 解析模型信息
		var backendType string
		if strings.Contains(selectedModel, "Ollama") {
			backendType = "ollama"
		} else if strings.Contains(selectedModel, "LMStudio") {
			backendType = "lmstudio"
		} else if strings.Contains(selectedModel, "xAI") {
			backendType = "xai"
		}

		// 更新配置
		cfg := config.Get()
		cfg.General.DefaultBackend = backendType

		// 重新创建AI后端
		backend, err := ai.NewBackend()
		if err != nil {
			m.setError(fmt.Errorf("切换到 %s 失败: %v", selectedModel, err))
		} else {
			m.aiBackend = backend
			m.addToHistory("system", fmt.Sprintf("✅ 已切换到模型: %s", selectedModel))
		}
	}

	// 隐藏模型选择器
	m.showModelSelector = false
}

// AIError 类型已在 model.go 中定义

// handlePauseResume 处理F12键的暂停/继续功能
func (m *Model) handlePauseResume() (tea.Model, tea.Cmd) {
	logger.Info("用户按下F12键，触发暂停/继续功能")

	// 检查是否在团队模式
	if m.multiAgentMgr == nil {
		m.addToHistory("system", "❌ 暂停功能仅在团队模式下可用")
		return m, nil
	}

	mode := m.multiAgentMgr.GetCurrentMode()
	if mode != "team" {
		m.addToHistory("system", "❌ 暂停功能仅在团队模式下可用")
		return m, nil
	}

	// 检查是否有当前项目
	if m.currentProject == "" {
		m.addToHistory("system", "❌ 请先使用 '/team 项目名称' 创建或恢复项目")
		return m, nil
	}

	// 实现暂停/继续状态切换
	if !m.isPaused {
		// 进入暂停状态
		m.isPaused = true
		m.pausePromptMode = true
		m.addToHistory("system", fmt.Sprintf("⏸️ 项目 '%s' 多Agent协作已暂停", m.currentProject))
		m.addToHistory("system", "💡 您现在可以输入指令来指导PM调整计划")
		m.addToHistory("system", "💡 输入完成后按Enter发送，按F12再次恢复协作")
		logger.Info("项目 '%s' 多Agent协作已暂停", m.currentProject)
	} else {
		// 恢复协作状态
		m.isPaused = false
		m.pausePromptMode = false
		m.addToHistory("system", fmt.Sprintf("▶️ 项目 '%s' 多Agent协作已恢复", m.currentProject))
		m.addToHistory("system", "🚀 继续执行项目任务...")
		logger.Info("项目 '%s' 多Agent协作已恢复", m.currentProject)
	}

	// 保存项目状态
	if err := m.multiAgentMgr.SaveProjectState(m.currentProject); err != nil {
		logger.Error("保存项目状态失败: %v", err)
		m.addToHistory("system", "⚠️ 项目状态保存失败")
	} else {
		m.addToHistory("system", "💾 项目状态已保存")
	}

	return m, nil
}

// handlePauseModeInput 处理暂停模式下的用户输入
func (m *Model) handlePauseModeInput(userInput string) (tea.Model, tea.Cmd) {
	logger.Info("处理暂停模式输入: %s", userInput)

	// 添加用户指令到历史
	m.addToHistory("user", fmt.Sprintf("📝 PM指令: %s", userInput))

	// 这里应该将指令发送给PM进行处理
	// 由于当前的多Agent系统架构，我们先模拟PM的响应
	pmResponse := fmt.Sprintf("🤖 PM已收到您的指令: '%s'\n💡 我将根据您的指导调整项目计划\n📋 建议: %s", userInput, generatePMGuidance(userInput))

	m.addToHistory("assistant", pmResponse)

	// 提示用户可以继续输入或按F12恢复
	m.addToHistory("system", "💡 继续输入指令，或按F12键恢复多Agent协作")

	return m, nil
}

// generatePMGuidance 根据用户输入生成PM指导建议
func generatePMGuidance(userInput string) string {
	// 简单的基于关键词的指导生成
	if strings.Contains(userInput, "优先") || strings.Contains(userInput, "重点") {
		return "我会调整任务优先级，将重点任务安排在前面执行"
	}
	if strings.Contains(userInput, "时间") || strings.Contains(userInput, "deadline") {
		return "我会优化时间安排，确保按时完成关键里程碑"
	}
	if strings.Contains(userInput, "质量") || strings.Contains(userInput, "标准") {
		return "我会加强质量控制，确保每个交付物符合标准"
	}
	if strings.Contains(userInput, "风险") || strings.Contains(userInput, "问题") {
		return "我会进行风险评估并制定应对策略"
	}

	return "我会综合考虑您的建议，优化项目执行方案"
}
